home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / Tetris Light 1.0 / source / game.c < prev    next >
Text File  |  1993-08-05  |  24KB  |  951 lines
  1. /**********************************************************************\
  2.  
  3. File:        game.c
  4.  
  5. Purpose:    This screen interface module for the Tetris program.  It is
  6.             also where the playing field is stored.  This was placed
  7.             here to simplify things if we want to port Tetris to 
  8.             a character based platform, where we could just read and
  9.             write characters to screen memory and use it to store the
  10.             grid!
  11.             
  12.  
  13. ``Tetris Light'' - a simple implementation of a Tetris game.
  14. Copyright (C) 1993 Hoylen Sue
  15.  
  16. This program is free software; you can redistribute it and/or modify
  17. it under the terms of the GNU General Public License as published by
  18. the Free Software Foundation; either version 2 of the License, or
  19. (at your option) any later version.
  20.  
  21. This program is distributed in the hope that it will be useful,
  22. but WITHOUT ANY WARRANTY; without even the implied warranty of
  23. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24. GNU General Public License for more details.
  25.  
  26. You should have received a copy of the GNU General Public License
  27. along with this program; see the file COPYING.  If not, write to the
  28. Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  
  30. \**********************************************************************/
  31.  
  32. #include "local.h"
  33.  
  34. #include <Sound.h>
  35.  
  36. #include "alert.h"
  37. #include "controls.h"
  38. #include "dialutil.h"
  39. #include "env.h"
  40. #include "game.h"
  41. #include "highscore.h"
  42. #include "pstring.h"
  43. #include "resources.h"
  44. #include "tetris.h"
  45. #include "windows.h"
  46.  
  47. /*--------------------------------------------------------------------*/
  48.  
  49. /* Coordinates of where to draw things (in pixels) */
  50.  
  51. #define FIELD_TOP    3
  52. #define FIELD_LEFT    3
  53. #define CELL_SIZE    16        /* Size of cell */
  54.  
  55. #define SCORE_VALUE_LEFT    170
  56. #define SCORE_VALUE_TOP        36
  57.  
  58. #define SCORE_TITLE_LEFT    170
  59. #define SCORE_TITLE_TOP        20
  60.  
  61. #define GAME_OVER_X            170
  62. #define GAME_OVER_Y            150
  63.  
  64. /* The following two are in cell units */
  65.  
  66. #define NEXT_PIECE_OFFSET_X    (NUMBER_COLS + 1)
  67. #define NEXT_PIECE_OFFSET_Y    3
  68.  
  69. /*--------------------------------------------------------------------*/
  70.  
  71. /* This macro symbol, if defined, compiles the code to draw using
  72.    primitive colours.  This will work on all Macs, but can be left
  73.    out to increase drawing efficiency. */
  74.    
  75. #define COLOUR_GRAPHICS 1
  76.  
  77. /*--------------------------------------------------------------------*/
  78.  
  79. /* Drawing and sound resources */
  80.  
  81. static Handle hit_snd = 0;    /* if null, use SysBeep */
  82. static Handle end_snd = 0;    /* if null, use SysBeep */
  83.  
  84. static unsigned char *score_str;
  85. static unsigned char *game_over_str;
  86.  
  87. static unsigned char *pause_str;
  88. static unsigned char *continue_str;
  89.  
  90. static Pattern cell_patterns[NUMBER_BLOCK_TYPES];
  91.  
  92. /*--------------------------------------------------------------------*/
  93.  
  94. /* The playing field and next block records */
  95.  
  96. static Rect field_rect = {
  97.     FIELD_TOP, FIELD_LEFT, FIELD_TOP + CELL_SIZE * NUMBER_ROWS, 
  98.     FIELD_LEFT + CELL_SIZE * NUMBER_COLS
  99. };
  100.  
  101. static unsigned char field[NUMBER_COLS][NUMBER_ROWS];
  102. static unsigned char next_block[MAX_BLOCK_SIZE][MAX_BLOCK_SIZE];
  103.  
  104. /*--------------------------------------------------------------------*/
  105.  
  106. static Boolean game_running;
  107. static Boolean game_paused;
  108. static Boolean game_window_active;    /* Records if game window is active */
  109.  
  110. static WindowPtr game_wind;
  111. static ControlHandle game_pause_ctrlh;
  112.  
  113. static RgnHandle rgn1;
  114. static RgnHandle rgn2;
  115. static RgnHandle rgn_top_row;
  116.  
  117. /*--------------------------------------------------------------------*/
  118.  
  119. /* Game file based saving and restoring routines */
  120.  
  121. static Boolean saved_file_known = FALSE;
  122. static Str255 saved_name;
  123. static INTEGER saved_vref;
  124.  
  125. struct Save_header {
  126.     unsigned long magic;
  127.     struct Tetris_state state;
  128. };
  129.  
  130. #define SAVE_MAGIC_NUMBER    ('TLsv' | 0x80808080)
  131.  
  132. /* These locations are based on centering the dialog in the classic
  133.    sized screen.  Dialog dimensions are based on those in Inside
  134.    Macintosh I. */
  135.  
  136. static const Point SFGetFile_where = {82, 103};
  137. static const Point SFPutFile_where = {104, 119};
  138.  
  139. /*--------------------------------------------------------------------*/
  140.  
  141. /* Local prototypes */
  142.  
  143. static void game_mouseDown(Point);
  144. static void game_key(unsigned char code, unsigned char ascii);
  145. static void game_update(void);
  146. static void game_activate(void);
  147. static void game_deactivate(void);
  148.  
  149. /*--------------------------------------------------------------------*/
  150.  
  151. /* Window dispatch table for game window */
  152.  
  153. static Wind_table game_dispatch_table = {
  154.     game_mouseDown,
  155.     game_key,
  156.     game_update,
  157.     game_activate,
  158.     game_deactivate
  159. };
  160.  
  161. /*--------------------------------------------------------------------*/
  162.  
  163. static void load_string(unsigned char **str, INTEGER resid)
  164. /* Tries to load the string resource with the given `resid' and sets
  165.    the pointer *str to it.  If it cannot be found, the pointer is set
  166.    to a default string.  Used by `game_init' to simplify code. */
  167. {
  168.     static unsigned char *default_string = "\p?";
  169.     
  170.     register StringHandle hand = GetString(resid);
  171.     if (hand != 0) {
  172.         HLock(hand);
  173.         *str = *hand;
  174.     } else
  175.         *str = default_string;
  176. }
  177.  
  178. /*--------------------------------------------------------------------*/
  179.  
  180. Boolean game_init(void)
  181. /* Initialization routine for game window.  Must be called at the
  182.    beginning of the program. Returns TRUE if it failed. */
  183. {
  184.     register int p;
  185.     Rect top_row;
  186.     
  187.     /* Load block patterns and strings */
  188.     
  189.     for (p = 0; p < NUMBER_BLOCK_TYPES; p ++)
  190.         GetIndPattern(cell_patterns + p, PATTERN_ID, p + 1);
  191.     
  192.     load_string(&score_str, SCORE_STR_ID);
  193.     load_string(&game_over_str, GAME_OVER_STR_ID);
  194.     load_string(&pause_str, PAUSE_STR_ID);
  195.     load_string(&continue_str, CONTINUE_STR_ID);
  196.  
  197.     /* Load sounds only if we can play them */
  198.     
  199.     if (env_SndPlay_available()) {
  200.         hit_snd = GetResource('snd ', HIT_SND_ID);
  201.         if (hit_snd != 0)
  202.             HLock(hit_snd);
  203.         end_snd = GetResource('snd ', END_SND_ID);
  204.         if (end_snd != 0)
  205.             HLock(end_snd);
  206.     }
  207.     
  208.     /* Set up drawing variables */
  209.     
  210.     rgn1 = NewRgn();
  211.     rgn2 = NewRgn();
  212.     rgn_top_row = NewRgn();
  213.     top_row = field_rect;
  214.     top_row.bottom = top_row.top + CELL_SIZE;
  215.     RectRgn(rgn_top_row, &top_row);
  216.     
  217.     /* Create and setup window and its button */
  218.     
  219.     game_wind = GetNewWindow(GAME_WINDOW_ID, NIL, (WindowPtr) -1);
  220.     if (game_wind == 0)
  221.         return TRUE;
  222.     SetWRefCon(game_wind, (LONGINT) &game_dispatch_table);
  223.     game_window_active = FALSE;
  224.     
  225.     game_pause_ctrlh = GetNewControl(GAME_PAUSE_CNTL_ID, game_wind);
  226.     if (game_pause_ctrlh == 0)
  227.         return TRUE;
  228.     
  229.     /* Set up */
  230.     
  231.     SetPort(game_wind);
  232.     TextFont(0); /* System font */
  233.     game_running = FALSE;
  234.     game_paused = FALSE;
  235.     
  236.     return FALSE; /* Success */
  237. } 
  238.  
  239. /*--------------------------------------------------------------------*/
  240.  
  241. void game_begin(void)
  242. /* Show the game window.  This is a separate routine so that we can
  243.    optionally load the location information from the preferences file
  244.    before showing the window. */
  245. {
  246.     ShowWindow(game_wind);
  247. }
  248.  
  249. /*--------------------------------------------------------------------*/
  250.  
  251. void game_term(void)
  252. /* To be called at the end of the program. */
  253. {
  254.     CloseRgn(rgn1);
  255.     CloseRgn(rgn2);
  256.     CloseRgn(rgn_top_row);
  257.     DisposeWindow(game_wind);    /* Controls automatically deleted */
  258. }
  259.  
  260. /*--------------------------------------------------------------------*/
  261.  
  262. static saved_file_set(unsigned char *name, INTEGER vref)
  263. {
  264.     if (name) {
  265.         pstrcpy(saved_name, name);
  266.         saved_vref = vref;
  267.         saved_file_known = TRUE;
  268.     } else {
  269.         pstrcpy(saved_name, "\pUntitled");
  270.         saved_file_known = FALSE;
  271.     }
  272.     
  273.     SetWTitle(game_wind, saved_name);
  274. }
  275.  
  276. /*====================================================================*/
  277.  
  278. /* Internal drawing routines */
  279.  
  280. static void draw_game_over(void)
  281. /* If the game is over, the game over message is drawn, otherwise the
  282.    location where that string goes is erased.  This routine is used to
  283.    both draw and erase this message. */
  284. {
  285.     if (! game_running) {
  286.         MoveTo(GAME_OVER_X, GAME_OVER_Y);
  287.         DrawString(game_over_str);
  288.     } else {
  289.         /* Determine where that string will be drawn and erase it. */
  290.         Rect r;
  291.         FontInfo fi;
  292.         
  293.         GetFontInfo(&fi);
  294.         
  295.         r.left = GAME_OVER_X;
  296.         r.right = GAME_OVER_X + StringWidth(game_over_str);
  297.         r.top = GAME_OVER_Y - fi.ascent;
  298.         r.bottom = GAME_OVER_Y + fi.descent;
  299.         
  300.         EraseRect(&r);
  301.     }
  302. }
  303.  
  304. /*--------------------------------------------------------------------*/
  305.  
  306. static void draw_score(void)
  307. /* Draws the value of the score in the game window. */
  308. {
  309.     Str255 score_string;
  310.     Rect    bound;
  311.     
  312.     bound.left = SCORE_VALUE_LEFT;
  313.     bound.top = SCORE_VALUE_TOP - 10;
  314.     bound.right = SCORE_VALUE_LEFT + 50;
  315.     bound.bottom = SCORE_VALUE_TOP + 4;
  316.     
  317.     SetPort(game_wind);
  318.  
  319.     EraseRect(&bound);
  320.     NumToString(tetris_score(), score_string);
  321.     MoveTo(SCORE_VALUE_LEFT, SCORE_VALUE_TOP);
  322.     DrawString(score_string);
  323. }
  324.  
  325. /*--------------------------------------------------------------------*/
  326.  
  327. static void draw_cell(int x, int y, unsigned char pattern)
  328. /* Internal routine to draw a cell on the screen display. Assumes
  329.    that the drawing port has already been set up.  If the pattern is
  330.    the empty cell (pattern == 0), the cell is erased. */
  331. {
  332.     Rect cell;
  333.     
  334.     cell.left = x * CELL_SIZE + FIELD_LEFT;
  335.     cell.top = y * CELL_SIZE + FIELD_TOP;
  336.     cell.right = cell.left + CELL_SIZE;
  337.     cell.bottom = cell.top + CELL_SIZE;
  338.         
  339.     if (pattern == 0)
  340.         EraseRect(&cell);
  341.     else {
  342. #ifdef COLOUR_GRAPHICS
  343.         ForeColor(greenColor);
  344. #endif
  345.  
  346.         FillRect(&cell, cell_patterns[pattern - 1]);
  347.         FrameRect(&cell);
  348.  
  349. #ifdef COLOUR_GRAPHICS
  350.         ForeColor(blackColor);
  351. #endif
  352.     }
  353. }
  354.  
  355. /*====================================================================*/
  356.  
  357. /* Dispatch table routines */
  358.  
  359. static void game_mouseDown(Point where)
  360. /* Handler for mouseDown events in the game window. Determines if the
  361.    pause/continue control has been hit, and processes it appropriately. */
  362. {
  363.     ControlHandle ctrl;
  364.     INTEGER part;
  365.     
  366.     SetPort(game_wind);
  367.     GlobalToLocal(&where);
  368.     part = FindControl(where, game_wind, &ctrl);
  369.  
  370.     if (ctrl != 0 && TrackControl(ctrl, where, NIL) != 0) {
  371.         if (game_paused) {
  372.             tetris_pause(FALSE);
  373.             SetCTitle(game_pause_ctrlh, pause_str);
  374.             game_paused = FALSE;
  375.         } else {
  376.             tetris_pause(TRUE);
  377.             SetCTitle(game_pause_ctrlh, continue_str);
  378.             game_paused = TRUE;
  379.         }
  380.     }
  381. }
  382.  
  383. /*--------------------------------------------------------------------*/
  384.  
  385. static void game_key(unsigned char code, unsigned char ascii)
  386. /* Handler for key presses when the game window is in front.
  387.    Recognizes the four control keys and processes them appropriately. */
  388. {
  389.     if (code == ctrls.code[KEY_LEFT])
  390.         tetris_try_move(move_left);
  391.     else if (code == ctrls.code[KEY_ROT])
  392.         tetris_try_move(move_anticlockwise);
  393.     else if (code == ctrls.code[KEY_RIGHT])
  394.         tetris_try_move(move_right);
  395.     else if (code == ctrls.code[KEY_DROP])
  396.         tetris_try_move(move_drop);
  397.     else {
  398.         /* Ignore all other keys */
  399.     }
  400. }
  401.  
  402. /*--------------------------------------------------------------------*/
  403.  
  404. static void game_update(void)
  405. /* Handler for update events to the game window.  Redraws the entire
  406.    game window. */
  407. {
  408.     register int x, y;
  409.     Rect r = field_rect;
  410.  
  411.     SetPort(game_wind);
  412.     DrawControls(game_wind);    
  413.     InsetRect(&r, -1, -1);
  414. #ifdef COLOUR_GRAPHICS
  415.     ForeColor(blueColor);
  416. #endif
  417.     FrameRect(&r);            /* Border to the playing field */
  418. #ifdef COLOUR_GRAPHICS
  419.     ForeColor(blackColor);
  420. #endif
  421.  
  422.     /* Show the score */
  423.     
  424.     MoveTo(SCORE_TITLE_LEFT, SCORE_TITLE_TOP);
  425.     DrawString(score_str);
  426.     draw_score();
  427.     
  428.     /* Field contents (draw from bottom up to look nice) */
  429.     
  430.     for (y = NUMBER_ROWS - 1; y >= 0; y--)
  431.         for (x = 0; x < NUMBER_COLS; x++)
  432.             if (field[x][y] != 0)
  433.                 draw_cell(x, y, field[x][y]);
  434.                 
  435.     /* The next block */
  436.     
  437.     for (x = 0; x < 4; x++)
  438.         for (y = 0; y < 4; y++)
  439.             if (next_block[x][y])
  440.                 draw_cell(x + NEXT_PIECE_OFFSET_X, y + NEXT_PIECE_OFFSET_Y,
  441.                           next_block[x][y]);
  442.  
  443.     /* Game over text, if appropriate */
  444.     
  445.     draw_game_over();
  446. }
  447.  
  448. /*--------------------------------------------------------------------*/
  449.  
  450. static void game_activate(void)
  451. /* Handler for activate events to the game window.  Takes game out of
  452.    any pause mode that was automatically entered when it went behind
  453.    another window. */
  454. {
  455.     HiliteControl(game_pause_ctrlh, 0); /* Activate it */
  456.     if (game_running && !game_paused)
  457.         tetris_pause(FALSE);
  458.  
  459.     game_window_active = TRUE;
  460. }
  461.  
  462. /*--------------------------------------------------------------------*/
  463.  
  464. static void game_deactivate(void)
  465. /* Handler for deactivate events to the game window.  Automatically
  466.    pauses the game. */
  467. {
  468.     HiliteControl(game_pause_ctrlh, 255);
  469.     if (game_running && !game_paused)
  470.         tetris_pause(TRUE);
  471.  
  472.     game_window_active = FALSE;
  473. }
  474.  
  475. /*====================================================================*/
  476.  
  477. /* Support routines for the tetris module */
  478.  
  479. void game_del_row(int victim)
  480. /* Called by the tetris module to remove a complete row from the playing
  481.    field. It is here that sounds are played and the display and field
  482.    updated. */
  483. {
  484.     register int row, col;
  485.     Rect area;
  486.  
  487. #ifdef COLOUR_GRAPHICS
  488.     /* Draws the border of the completed row in red before playing the
  489.        sound.  Should be nice if you have a colour Mac. */
  490.        
  491.     ForeColor(redColor);
  492.  
  493.     area.top = FIELD_TOP + CELL_SIZE * victim;
  494.     area.left = FIELD_LEFT;
  495.     area.bottom = area.top + CELL_SIZE; 
  496.     area.right = FIELD_LEFT + CELL_SIZE * NUMBER_COLS;
  497.     FrameRect(&area);
  498.  
  499.     ForeColor(blackColor);
  500. #endif
  501.  
  502.     /* Play the sound */
  503.     
  504.     if (ctrls.sound_on)
  505.         if (hit_snd == 0 || SndPlay(NIL, hit_snd, FALSE) != noErr)
  506.             SysBeep(5);
  507.     
  508.     /* Delete row from field array */
  509.         
  510.     for (row = victim - 1; row >= 0; row--)
  511.         for (col = 0; col < NUMBER_COLS; col++)
  512.             field[col][row + 1] = field[col][row];
  513.             
  514.     for (col = 0; col < NUMBER_COLS; col++)
  515.         field[col][0] = 0;
  516.     
  517.     /* Display this on the screen */
  518.     
  519.     area.top = FIELD_TOP;
  520.     area.left = FIELD_LEFT;
  521.     area.bottom = FIELD_TOP + CELL_SIZE * (victim + 1); 
  522.     area.right = FIELD_LEFT + CELL_SIZE * NUMBER_COLS;
  523.  
  524.     SetPort(game_wind);
  525.     ScrollRect(&area, 0, CELL_SIZE, rgn1);
  526.  
  527.     /* Need to redraw entire field if more than just the top becomes
  528.        invalid.  This is because we do not know if more rows will be
  529.        deleted after this, and hence we may be scrolling invalid
  530.        regions around.  We can't just invalidate this rgn1 because
  531.        the next scroll will move the bad pixels from under it. */
  532.     
  533.     DiffRgn(rgn1, rgn_top_row, rgn2);
  534.     if (! EmptyRgn(rgn2))
  535.         game_update();
  536. }
  537.  
  538. /*--------------------------------------------------------------------*/
  539.  
  540. void game_set(int x, int y, unsigned char pattern)
  541. /* Called by the tetris module to set a field element. If the cell is
  542.    valid, its value is stored and it is redrawn. */
  543. {
  544.     if (x < 0 || x >= NUMBER_COLS || y < 0 || y >= NUMBER_ROWS)
  545.         return;
  546.     
  547.     field[x][y] = pattern;
  548.     SetPort(game_wind);
  549.     draw_cell(x, y, pattern);
  550. }
  551.  
  552. /*--------------------------------------------------------------------*/
  553.  
  554. unsigned char game_get(int x, int y)
  555. /* Called by the tetris module to get the value of a field element.  If
  556.    the coordinates of the cell are invalid, 0 is returned. */
  557. {
  558.     if (x < 0 || x >= NUMBER_COLS || y < 0 || y >= NUMBER_ROWS)
  559.         return 0;
  560.     else
  561.         return field[x][y];
  562. }
  563.  
  564. /*--------------------------------------------------------------------*/
  565.  
  566. void game_score_changed(void)
  567. /* Called by the tetris module to indicate that the score has changed.
  568.    This function draws the new score on the screen. */
  569. {
  570.     draw_score();
  571. }
  572.  
  573. /*--------------------------------------------------------------------*/
  574.  
  575. void game_over(void)
  576. /* Called by the tetris module to indicate the game is over.  Plays
  577.    a sound and updates the display, trying to record the score in the
  578.    high score list. */
  579. {
  580.     if (ctrls.sound_on)
  581.         if (end_snd == 0 || SndPlay(NIL, end_snd, FALSE) != noErr)
  582.             SysBeep(5);
  583.     
  584.     game_running = FALSE;
  585.     SetPort(game_wind);
  586.     draw_game_over();
  587.     
  588.     HiliteControl(game_pause_ctrlh, 255); /* make inactive */
  589.     
  590.     highscore_add(tetris_score());
  591. }
  592.  
  593. /*--------------------------------------------------------------------*/
  594.  
  595. void describe_next_begin(void)
  596. /* Called by the tetris module to indicate that it is about to describe
  597.    the cells of the next block to be played (by calling the 
  598.    `describe_next_cell' below).  We clear the local record of the next
  599.    block. */
  600. {
  601.     register int x, y;
  602.     
  603.     SetPort(game_wind);
  604.  
  605.     for (x = 0; x < 4; x++)
  606.         for (y = 0; y < 4; y++)
  607.             next_block[x][y] = 0;
  608. }
  609.  
  610. /*--------------------------------------------------------------------*/
  611.  
  612. void describe_next_cell(int x, int y, unsigned char pattern)
  613. /* Used by the tetris module to describe the cells of the next block.
  614.    Will be called between calls to `describe_next_begin' and 
  615.    `describe_next_end'. */
  616. {
  617.     if (ctrls.show_next_piece)
  618.         next_block[x][y] = pattern;
  619. }
  620.  
  621. /*--------------------------------------------------------------------*/
  622.  
  623. void describe_next_end(void)
  624. /* Used by the tetris module to indicate that it is finished describing
  625.    the next block.  Invalidates the next block's display rectangular
  626.    area so that it will be updated. */
  627. {
  628.     Rect r;
  629.     
  630.     r.left = NEXT_PIECE_OFFSET_X * CELL_SIZE + FIELD_LEFT;
  631.     r.top = NEXT_PIECE_OFFSET_Y * CELL_SIZE + FIELD_TOP;
  632.     r.right = r.left + CELL_SIZE * MAX_BLOCK_SIZE;
  633.     r.bottom = r.top + CELL_SIZE * MAX_BLOCK_SIZE;
  634.     
  635.     SetPort(game_wind);
  636.     EraseRect(&r);
  637.     InvalRect(&r);
  638. }
  639.  
  640. /*====================================================================*/
  641.  
  642. /* Other interfaces to higher modules */
  643.  
  644. void game_periodic(void)
  645. /* This routine is called as often as possible.  It calls the tetris
  646.    peridic routine as often as possible when the game is played. */
  647. {
  648.     if (game_window_active && !game_paused && game_running)
  649.         tetris_periodic();
  650. }
  651.  
  652. /*--------------------------------------------------------------------*/
  653.  
  654. void game_new(void)
  655. /* This routine starts a new game, and resets the save file name and
  656.    window title. It does not ask the user whether to save the current
  657.    game or not - it is discarded. */
  658. {
  659.     register int x, y;
  660.     
  661.     /* Clears the field and next block to be empty */
  662.     
  663.     for (y = 0; y < NUMBER_ROWS; y++)
  664.         for (x = 0; x < NUMBER_COLS; x++)
  665.             field[x][y] = 0;
  666.         
  667.     /* Reset the pause push button */
  668.     
  669.     if (game_window_active)
  670.         HiliteControl(game_pause_ctrlh, 0);
  671.     
  672.     /* Start up the game */
  673.     
  674.     tetris_start(0);
  675.     game_running = TRUE;
  676.     game_paused = FALSE;
  677.     SetCTitle(game_pause_ctrlh, pause_str);
  678.     
  679.     /* Fix up the display */
  680.     
  681.     SetPort(game_wind);
  682.     EraseRect(&field_rect);
  683.     InvalRect(&field_rect);
  684.     draw_game_over();
  685.     draw_score();
  686.  
  687.     saved_file_set(0, 0);
  688. }
  689.  
  690. /*--------------------------------------------------------------------*/
  691.  
  692. void game_save_as(void)
  693. /* Save the current game under a new file, ignoring the file it might
  694.    have come from. */
  695. {
  696.     register INTEGER erc;
  697.     INTEGER file_ref;
  698.     SFReply reply;
  699.     
  700.     /* Get the file to save to */
  701.     
  702.     SFPutFile(SFPutFile_where, "\pSave game as:", "\pUntitled", NIL, &reply);
  703.     if (reply.good) {
  704.         saved_file_set(reply.fName, reply.vRefNum);
  705.         game_save();
  706.     }
  707. }
  708.  
  709. /*--------------------------------------------------------------------*/
  710.  
  711. void game_save(void)
  712. /* Creates and writes out the game information to the file specified
  713.    in `saved_reply'. If the file name is not already known, it calls
  714.    `game_save_as' to find it first. */
  715. {
  716.     OSErr erc;
  717.     LONGINT size;
  718.     INTEGER file_ref;
  719.     struct Save_header header;
  720.     
  721.     if (! saved_file_known) {
  722.         game_save_as();
  723.         return;
  724.     }
  725.         
  726.     /* Create the file, ignore error if it says it already exists */
  727.     
  728.     erc = Create(saved_name, saved_vref, CREATOR_SIGNATURE, SAVE_FILE_SIGNATURE);
  729.     if (erc != noErr && erc != dupFNErr) {
  730.         ParamText(saved_name, 0, 0, 0);
  731.         alert_erc(1, erc);
  732.         saved_file_set(0, 0);
  733.         return;
  734.     }
  735.  
  736.     erc = FSOpen(saved_name, saved_vref, &file_ref);
  737.     if (erc != noErr) {
  738.         ParamText(saved_name, 0, 0, 0);
  739.         alert_erc(2, erc);
  740.         saved_file_set(0, 0);
  741.         return;
  742.     }
  743.     
  744.     /* Fill in the header information */
  745.     
  746.     header.magic = SAVE_MAGIC_NUMBER;
  747.     tetris_state_get(&header.state);
  748.     
  749.     /* Write out the data */
  750.     
  751.     size = sizeof(header);
  752.     erc = FSWrite(file_ref, &size, &header);
  753.     if (erc != noErr || size != sizeof(header)) {
  754.         ParamText(saved_name, 0, 0, 0);
  755.         alert_erc(4, erc);
  756.         (void) FSClose(file_ref);
  757.         saved_file_set(0, 0);
  758.         return;
  759.     }
  760.  
  761.     size = sizeof(field);
  762.     erc = FSWrite(file_ref, &size, field);
  763.     if (erc != noErr || size != sizeof(field)) {
  764.         ParamText(saved_name, 0, 0, 0);
  765.         alert_erc(4, erc);
  766.         (void) FSClose(file_ref);
  767.         saved_file_set(0, 0);
  768.         return;
  769.     }
  770.     
  771.     /* Close file */
  772.     
  773.     erc = FSClose(file_ref);
  774.     if (erc != noErr) {
  775.         ParamText(saved_name, 0, 0, 0);
  776.         alert_erc(5, erc);
  777.         saved_file_set(0, 0);
  778.         return;
  779.     }
  780. }
  781.  
  782. /*--------------------------------------------------------------------*/
  783.  
  784. void game_open(void)
  785. /* Asks the user for a game save file.  If the user supplies one, it
  786.    is loaded up as the game to be played. */
  787. {
  788.     static SFTypeList sig_list = { SAVE_FILE_SIGNATURE };
  789.     SFReply reply;
  790.     
  791.     SFGetFile(SFGetFile_where, NIL, NIL, 1, sig_list, NIL, &reply);
  792.     if (reply.good)
  793.         game_load(reply.fName, reply.vRefNum);        
  794. }
  795.  
  796. /*--------------------------------------------------------------------*/
  797.  
  798. void game_load(Str255 fname, INTEGER vref)
  799. /* Loads the game from the given file. */
  800. {
  801.     OSErr erc;
  802.     INTEGER file_ref;
  803.     LONGINT size;
  804.     struct Save_header header;
  805.     unsigned char new_field[NUMBER_COLS][NUMBER_ROWS];
  806.     register int x, y;
  807.     
  808.     /* Open the save file */
  809.     
  810.     erc = FSOpen(fname, vref, &file_ref);
  811.     if (erc != noErr) {
  812.         ParamText(fname, 0, 0, 0);
  813.         alert_erc(2, erc);
  814.         return;
  815.     }
  816.     
  817.     /* Load the game */
  818.     
  819.     size = sizeof(header);
  820.     erc = FSRead(file_ref, &size, &header);
  821.     if (erc != noErr || size != sizeof(header)) {
  822.         ParamText(fname, 0, 0, 0);
  823.         alert_erc(3, erc);
  824.         (void) FSClose(file_ref);
  825.         return;
  826.     }
  827.     
  828.     size = sizeof(new_field);
  829.     erc = FSRead(file_ref, &size, new_field);
  830.     if (erc != noErr || size != sizeof(new_field)) {
  831.         ParamText(fname, 0, 0, 0);
  832.         alert_erc(3, erc);
  833.         return;
  834.     }
  835.     
  836.     /* Close the file */
  837.     
  838.     erc = FSClose(file_ref);
  839.     if (erc != noErr) {
  840.         ParamText(fname, 0, 0, 0);
  841.         alert_erc(5, erc);
  842.         return;
  843.     }
  844.  
  845.     /* Verify header */
  846.     
  847.     if (header.magic != SAVE_MAGIC_NUMBER) {
  848.         ParamText(fname, 0, 0, 0);
  849.         alert_caution(2);
  850.         return;
  851.     }
  852.     
  853.     /* Use field values, filtering out invalid values */
  854.     
  855.     for (x = 0; x < NUMBER_COLS; x++)
  856.         for (y = 0; y < NUMBER_ROWS; y++)
  857.             field[x][y] = new_field[x][y] % (NUMBER_BLOCK_TYPES + 1);
  858.     
  859.     /* Record this file as the saved file */
  860.     
  861.     saved_file_set(fname, vref);
  862.     
  863.     /* Start play */
  864.     
  865.     tetris_start(&header.state);
  866.     game_running = TRUE;
  867.     game_paused = FALSE;
  868.     SetCTitle(game_pause_ctrlh, pause_str);
  869.  
  870.     /* Update the screen */
  871.         
  872.     SetPort(game_wind);
  873.     draw_score();
  874.     draw_game_over();
  875.     EraseRect(&field_rect);
  876.     InvalRect(&field_rect);
  877. }
  878.  
  879. /*--------------------------------------------------------------------*/
  880.  
  881. OSErr game_save_location(INTEGER pref_file)
  882. /* Saves the game controls and user settings to the given resource
  883.    file. */
  884. {
  885.     OSErr erc;
  886.     LONGINT size;
  887.     Point **handle;
  888.     Rect r;
  889.     
  890.     r = (**(*(WindowPeek)game_wind).contRgn).rgnBBox;
  891.     
  892.     handle = (Point **) GetResource(PREF_RSRC_TYPE, GAME_WPOS_PREF_ID);
  893.     if (handle != NIL && HomeResFile(handle) == pref_file) {
  894.         RmveResource(handle);
  895.         erc = ResError();
  896.         if (erc != noErr)
  897.             return erc;
  898.         
  899.         DisposHandle(handle);
  900.     }
  901.     
  902.     /* Create new resource */
  903.     
  904.     erc = PtrToHand(&r, &handle, sizeof(Rect));
  905.     if (erc != noErr)
  906.         return erc;
  907.         
  908.     AddResource(handle, PREF_RSRC_TYPE, GAME_WPOS_PREF_ID, "\p");
  909.     erc = ResError();
  910.     if (erc != noErr)
  911.         return erc;
  912.     
  913.     return noErr;
  914. }
  915.  
  916. /*--------------------------------------------------------------------*/
  917.  
  918. void game_load_location(void)
  919. /* Tries to read the window position information resource.  This is
  920.    found in the preference file, so it should be open at this stage.
  921.    If it is found and the location places the top right or the top left
  922.    corner in the desktop, it is moved to that location, otherwise it is
  923.    left alone. */
  924. {
  925.     register OSErr erc;
  926.     LONGINT size;
  927.     struct Rect **handle;
  928.     
  929.     handle = (struct Rect **) GetResource(PREF_RSRC_TYPE, GAME_WPOS_PREF_ID);
  930.     if (handle) {
  931.         Point ul, ur;
  932.         
  933.         ul.h = (*handle)->left;
  934.         ul.v = (*handle)->top;
  935.         ur.h = (*handle)->right;
  936.         ur.v = (*handle)->top;
  937.         
  938.         if (PtInRgn(ul, GrayRgn) || PtInRgn(ur, GrayRgn))
  939.             MoveWindow(game_wind, (*handle)->left, (*handle)->top, TRUE);
  940.     }
  941. }
  942.  
  943. /*--------------------------------------------------------------------*/
  944.  
  945. extern Boolean game_is_over(void)
  946. {
  947.     return (! game_running);
  948. }
  949.  
  950. /*--------------------------------------------------------------------*/
  951.